// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_OBJECTS_LITERAL_OBJECTS_H_
#define V8_OBJECTS_LITERAL_OBJECTS_H_

#include "src/objects/fixed-array.h"
#include "src/objects/struct.h"

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {

    class ClassLiteral;

    // ObjectBoilerplateDescription is a list of properties consisting of name value
    // pairs. In addition to the properties, it provides the projected number
    // of properties in the backing store. This number includes properties with
    // computed names that are not
    // in the list.
    class ObjectBoilerplateDescription : public FixedArray {
    public:
        Object name(int index) const;
        Object value(int index) const;

        void set_key_value(int index, Object key, Object value);

        // The number of boilerplate properties.
        int size() const;

        // Number of boilerplate properties and properties with computed names.
        int backing_store_size() const;

        void set_backing_store_size(Isolate* isolate, int backing_store_size);

        // Used to encode ObjectLiteral::Flags for nested object literals
        // Stored as the first element of the fixed array
        DECL_INT_ACCESSORS(flags)
        static const int kLiteralTypeOffset = 0;
        static const int kDescriptionStartIndex = 1;

        DECL_CAST(ObjectBoilerplateDescription)
        DECL_VERIFIER(ObjectBoilerplateDescription)
        DECL_PRINTER(ObjectBoilerplateDescription)

    private:
        bool has_number_of_properties() const;

        OBJECT_CONSTRUCTORS(ObjectBoilerplateDescription, FixedArray);
    };

    class ArrayBoilerplateDescription : public Struct {
    public:
        // store constant_elements of a fixed array
        DECL_ACCESSORS(constant_elements, FixedArrayBase)

        inline ElementsKind elements_kind() const;
        inline void set_elements_kind(ElementsKind kind);

        inline bool is_empty() const;

        DECL_CAST(ArrayBoilerplateDescription)
        // Dispatched behavior.
        DECL_PRINTER(ArrayBoilerplateDescription)
        DECL_VERIFIER(ArrayBoilerplateDescription)
        void BriefPrintDetails(std::ostream& os);

        DEFINE_FIELD_OFFSET_CONSTANTS(
            HeapObject::kHeaderSize,
            TORQUE_GENERATED_ARRAY_BOILERPLATE_DESCRIPTION_FIELDS)

    private:
        DECL_INT_ACCESSORS(flags)
        OBJECT_CONSTRUCTORS(ArrayBoilerplateDescription, Struct);
    };

    class ClassBoilerplate : public FixedArray {
    public:
        enum ValueKind { kData,
            kGetter,
            kSetter };

        struct Flags {
#define FLAGS_BIT_FIELDS(V, _)                 \
    V(InstallClassNameAccessorBit, bool, 1, _) \
    V(ArgumentsCountBits, int, 30, _)
            DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS)
#undef FLAGS_BIT_FIELDS
        };

        struct ComputedEntryFlags {
#define COMPUTED_ENTRY_BIT_FIELDS(V, _) \
    V(ValueKindBits, ValueKind, 2, _)   \
    V(KeyIndexBits, unsigned, 29, _)
            DEFINE_BIT_FIELDS(COMPUTED_ENTRY_BIT_FIELDS)
#undef COMPUTED_ENTRY_BIT_FIELDS
        };

        enum DefineClassArgumentsIndices {
            kConstructorArgumentIndex = 1,
            kPrototypeArgumentIndex = 2,
            // The index of a first dynamic argument passed to Runtime::kDefineClass
            // function. The dynamic arguments are consist of method closures and
            // computed property names.
            kFirstDynamicArgumentIndex = 3,
        };

        static const int kMinimumClassPropertiesCount = 6;
        static const int kMinimumPrototypePropertiesCount = 1;

        DECL_CAST(ClassBoilerplate)

        DECL_BOOLEAN_ACCESSORS(install_class_name_accessor)
        DECL_INT_ACCESSORS(arguments_count)
        DECL_ACCESSORS(static_properties_template, Object)
        DECL_ACCESSORS(static_elements_template, Object)
        DECL_ACCESSORS(static_computed_properties, FixedArray)
        DECL_ACCESSORS(instance_properties_template, Object)
        DECL_ACCESSORS(instance_elements_template, Object)
        DECL_ACCESSORS(instance_computed_properties, FixedArray)

        static void AddToPropertiesTemplate(Isolate* isolate,
            Handle<NameDictionary> dictionary,
            Handle<Name> name, int key_index,
            ValueKind value_kind, Object value);

        static void AddToElementsTemplate(Isolate* isolate,
            Handle<NumberDictionary> dictionary,
            uint32_t key, int key_index,
            ValueKind value_kind, Object value);

        static Handle<ClassBoilerplate> BuildClassBoilerplate(Isolate* isolate,
            ClassLiteral* expr);

        enum {
            kFlagsIndex,
            kClassPropertiesTemplateIndex,
            kClassElementsTemplateIndex,
            kClassComputedPropertiesIndex,
            kPrototypePropertiesTemplateIndex,
            kPrototypeElementsTemplateIndex,
            kPrototypeComputedPropertiesIndex,
            kBoileplateLength // last element
        };

        static const int kFullComputedEntrySize = 2;

    private:
        DECL_INT_ACCESSORS(flags)

        OBJECT_CONSTRUCTORS(ClassBoilerplate, FixedArray);
    };

} // namespace internal
} // namespace v8

#include "src/objects/object-macros-undef.h"

#endif // V8_OBJECTS_LITERAL_OBJECTS_H_
